'use strict';

export enum EnumType {
  FOLDER = 'FOLDER',
  FILE = 'FILE'
}

export default app => {
  const mongoose = app.mongoose;
  const Schema = mongoose.Schema;

  const EnumSchema = new Schema({
    /**
     * 标题
     */
    name: { type: String, default: '' },
    /**
     * 索引，用来排序
     */
    index: { type: Number, default: 0, min: 0, max: 9 },
    /**
     * 类型，文件夹/子文件夹/文件
     */
    type: { type: String, default: EnumType.FOLDER, enum: [ EnumType.FOLDER, EnumType.FILE ] },
    /**
     * 路径
     */
    path: { type: String, default: '' },
    /**
     * 子对象
     */
    children: [{ type: Schema.Types.ObjectId, ref: 'Enum' }],
    /**
     * 对应的项目ID，因为需要权限校验，只有符合的权限项目才能修改
     */
    project: { type: Schema.Types.ObjectId, ref: 'Project' },
    /**
     * UUID
     */
    uuid: { type: String, unique: true, index: true },
    /**
     * 描述
     */
    description: { type: String, default: '' },
    /**
     * 创建时间
     */
    createTime: { type: Date, default: new Date() },
    /**
     * 层次
     */
    tier: { type: Number, default: 0, min: 0, max: 2 },
    /**
     * 当前的数据
     */
    data: { type: Schema.Types.ObjectId, ref: 'Data' },
    /**
     * 创建人
     */
    createUser: { type: Schema.Types.ObjectId, ref: 'User' },
    /**
     * 数据说明
     */
    dataShow: { type: String, default: '' },
  });

  /**
   * 查询单个数据
   */
  EnumSchema.statics.findWithId = async function(id) {
    return this.findOne({
      _id: mongoose.Types.ObjectId(id),
    });
  };

  /**
   * 查询单个数据(Data)
   */
  EnumSchema.statics.findOneDataWithId = async function(id) {
    return this.findOne({
      _id: mongoose.Types.ObjectId(id),
    }, 'data')
    .populate({
      path: 'data',
      populate: {
        path: 'createUser',
        select: 'name'
      }
    })
    .exec();
  };

  /**
   * 查询单个数据(Data)
   */
  EnumSchema.statics.findOneDataWithUUID = async function(uuid: string) {
    return this.findOne({
      uuid
    }, 'data')
    .populate({
      path: 'data',
      select: 'data createTime'
    })
    .exec();
  };

  /**
   * 查询单个数据(Data)
   */
  EnumSchema.statics.getIdWithUUID = async function(uuid: string) {
    const model = await this.findOne({uuid}, 'uuid').exec();
    return model._id
  };

  /**
   * 查询单个数据(详情，包含创建人，归属项目)
   */
  EnumSchema.statics.findDetailWithId = async function(id) {
    return this.findOne({
      _id: mongoose.Types.ObjectId(id),
    })
    .populate({
      path: 'createUser',
      select: 'name'
    })
    .populate({
      path: 'project',
      select: 'name'
    }).exec()
  };

  /**
   * 添加ENUM
   */
  EnumSchema.statics.addEnum = async function(id, enumId) {
    return this.updateOne({
      _id: mongoose.Types.ObjectId(id),
    }, {
      $push: {
        children: mongoose.Types.ObjectId(enumId),
      },
    });
  };

  /**
   * 更新数据
   */
  EnumSchema.statics.updateWithId = function(id, upData) {
    return this.updateOne({ 
      _id: mongoose.Types.ObjectId(id)
    }, upData);
  };

  /**
   * 更新数据
   */
  EnumSchema.statics.updateWithUUID = function(uuid, upData) {
    return this.updateOne({ 
      uuid
    }, upData);
  };

  /**
   * 删除ENUM
   */
  EnumSchema.statics.removeChildren = async function(id, enumId) {
    // 删除父节点里面的数据
    await this.updateOne({
      _id: mongoose.Types.ObjectId(id),
    }, {
      $pull: {
        children: mongoose.Types.ObjectId(enumId),
      },
    });
  }

  /**
   * 删除
   */
  EnumSchema.statics.removeEnum = function(id) {
    return this.deleteOne({
      _id: mongoose.Types.ObjectId(id),
    });
  };

  /**
   * 批量删除数据
   */
  EnumSchema.statics.removeWithQuery = function(query) {
    return this.deleteMany(query);
  };

  return mongoose.model('Enum', EnumSchema, 'enums');
};
